<<<<<<< HEAD
// #include<iostream>
// #include<vector>
// #include<string>
// #include<algorithm>
// using namespace std;
// #include<queue>
// #include<functional>
// #include<math.h>
// #include<numeric>
// #include<string.h>

// class Solution{
// public:
//     int func01(vector<int> nums,int n){
//         if(nums.empty()){
//             return 0;
//         }
//         int size = nums.size();
//         sort(nums.begin(),nums.end());
//         //先把后面n个人提出来
//         priority_queue<int,vector<int>,greater<int>> Q;
//         int sum = accumulate(nums.begin(),nums.end(),0); 
//         int sumT = accumulate(nums.rbegin(),nums.rbegin()+n,0);
//         for(int i = 1;i<=n;++i){
//             Q.push(nums[size-i]);
//         }
//         int index = size-n-1;
//         while(index>=0){
//             if(sum-sumT<=Q.top()){
//                 return sum-sumT;
//             }
//             else{
//                 int temp = Q.top()+nums[index];
//                 sumT += nums[index];
//                 Q.pop();
//                 Q.push(temp);
//             }
//             --index;

//         }
//         return 0;

//     }
// };

// int main(){
//     Solution S;
//     vector<int> nums = {1,2,3,4,5};
//     cout<<S.func01(nums,3)<<endl;
// }
// #define Find(A,e) (size_t)&(((A*)0)->e)
// struct A{
//     int a;
//     int b[20];
//     double c;
//     char d;
// };

// int main(){
//     A T;
//     A* p;
//     cout<<size_t(&p)<<endl;
//     cout<<size_t(&(p->d))<<endl;
    
// }

// using namespace std;
// #define FIND(struc,e) (size_t)&(((struc*)0)->e)

// struct struc
// {
// int a; //a的偏移量是0
// int b[20]; //b的偏移量是4，因为a的偏移量是0，b的偏移量是a的偏移量加上a的类型的大小算出来的，a是int型的，所以a要占4个字节（在64位机子上），b的偏移量是4
// double c; //c的偏移量是88,因为b的偏移量是4，而b所占的字节数是80，所以本来c的偏移量应该是84，但是偏移量的大小又该是这个变量类型的整数倍，即应该是c的                                        //double类型的8的倍数，所以只能是88
// char d; //偏移量是96，是88+8
// };
// int main()
// {
// cout<<FIND(struc,d)<<endl;//偏移量的大小必须是该类型的倍数
// cout<<sizeof(struc)<<endl;//计算结构体的大小看最后一个变量的偏移量为96，它的大小本来是最后一个变量的偏移量加上最后一个变量的大小，即97，但是这个结构体的大                                                           //小必须是8的倍数（因为结构体里面有一个double类型，必须是8的倍数），所以是104
// }




// int main(){
//     int index =1;
//     while(1){
//         int a=0;       
//         if(index==1){
//             a=2;
//             index=0;
//         }
//         cout<<a<<endl;

//     }
// }


// class Solution{
// public:
//     int func(vector<int>& V,int i){
//         //计算V中的可能或和
//         if(i==V.size()){
//             return 0;
//         }
        
//         int temp = func(V,i+1);
//         int result = temp+V[i];
//         for(int j = i+1;j<V.size();++j){
//             result += (V[i]|V[j]);
//         }
//         return result;
//     }

// };

// class Solution{
// public:
//     void func(vector<vector<int>>& V,int i,int M,int K,int& result,int sonResult){
        
//         if(i>=V.size()||M<=0||K<0){
//             if(M<0){
//                 result = max(result,sonResult-V[i-1][1]);
//             }
//             else{
//                 result = max(result,sonResult);
//             }
//             return;
//         }
//         func(V,i+1,M,K,result,sonResult);
//         func(V,i+1,M-V[i][0],K-1,result,sonResult+V[i][1]);
        
//     }

// };


// int main(){
//    char buf[1024]={0};
//    cout<<strlen(buf)<<endl;
//    return 0;
// }

#include <iostream>
using namespace std;

struct TreeNode{
    int val;
    TreeNode* left;
    TreeNode* right;
};

//a nonrecursion way to create a binary tree based on a array
TreeNode* createBiTree(int nums[], int size){
    if(size == 0){
        return nullptr;
    }

    //open up the space
    //root means a head of the TreeNode array
    TreeNode* root = (TreeNode*)malloc(sizeof(TreeNode*) * size);

    //at first, assign the value
    //keep the pointer empty
    for(int i = 0; i < size; i++){
        root[i].val = nums[i];
        root[i].left = nullptr;
        root[i].right = nullptr;
    }

    // /cond, point to the right place
    for(int i = 0; i < size / 2; i++){
        if(2 * i + 1 < size){
            root[i].left = &root[2 * i + 1];
        }
        if(2 * i + 2 < size){
            root[i].right = &root[2 * i + 2];
        }
    }
    return root;
}

//pre in post layer traversal the tree
void preTraversal(TreeNode* root){
    if(!root){
        return;
    }
    cout << root->val << " ";
    preTraversal(root->left);
    preTraversal(root->right);
}
void inTraversal(TreeNode* root){
    if(!root){
        return;
    }
    preTraversal(root->left);
    cout << root->val << " ";
    preTraversal(root->right);
}
void postTraversal(TreeNode* root){
    if(!root){
        return;
    }
    preTraversal(root->left);
    preTraversal(root->right);
    cout << root->val << " ";
}

void layerTraversal(TreeNode* root){

}

//find a element

//get th depth and the width




int main() {
    int nums[] = {1, 2, 3, 4, 5, 6, 7};
    int size = sizeof(nums) / sizeof(nums[0]);

    TreeNode* root = new TreeNode;
    root = createBiTree(nums, size);
   cout << "pre order : "<<endl;
    preTraversal(root);
    cout << endl <<  "in order : ";
    inTraversal(root);
    cout << endl <<  "post order : ";
    inTraversal(root);


    system("pause");
    return 0;
}
=======
#include<iostream>
#include<vector>
#include<string>
#include<algorithm>
#include<stack>
#include<deque>
using namespace std;

// class Solution{
// public:
//     string func(string str,int K)
//     {
//         string result = "";
//         deque<pair<char,int>> S;
//         for(int i = 0;i<str.size();++i){
//             if(S.empty()){
//                 S.push_back(make_pair(str[i],1));
//             }
//             else{
//                 if(str[i]==S.back().first){
//                     ++S.back().second;
//                     if(S.back().second == K){
//                         S.pop_back();
//                     }
//                 }
//                 else{
//                     S.push_back(make_pair(str[i],1));
//                 }
//             }

//         }
//         for(auto i:S){
//             result += string(i.second,i.first);
//         }
//         return result;

//     }
// };

// int main(){
//     string str;
//     cin>>str;
//     Solution S;
//     int K;
//     cin>>K;
//     cout<<S.func(str,K)<<endl;

// }

class Solution {
public:
    int countBattleships(vector<vector<char>> board) {
        int count = 0;
        for (int i = 0; i < board.size(); i++) {
            for (int j = 0; j < board[0].size(); j++) {
                if (board[i][j] == 'X') {
                    count++;
                    board[i][j] = '.';
                    int a = i + 1;
                    int b = j;
                    // 遍历行
                    while (a < board.size() && board[a][b] == 'X') {
                        board[a++][b] = '.';
                    }
                    a = i;
                    b = j + 1;
                    // 遍历列
                    while (b < board[0].size() && board[a][b] == 'X') {
                        board[a][b++] = '.';
                    }
                }
            }
        }
        return count;
    }
};

int main(){
    int n,m;
    cin>>n>>m;
    vector<vector<char>> board(n,vector<char>(m,'.'));
    int t;
    for(int i = 0;i<n;++i){
        for(int j = 0;j<m;j++){
            cin>>board[i][j];
            getchar();
        }
    }
    Solution S;
    cout<<S.countBattleships(board)<<endl;
}
>>>>>>> cf01110d1a883a01edf997edaf0ddeaa246634e5
